package u2

import (
	"bytes"
	"encoding/json"
	"strings"
)

// Struct2JSON 将结构体转换为JSON字符串
//
// 参数：
//
//	t - 要转换的结构体或值
//	pretty - 是否格式化输出
//
// 返回值：
//
//	string - 转换后的JSON字符串
//	error - 转换过程中可能发生的错误
//
// 示例：
//
//	type User struct {
//	    Name string `json:"name"`
//	    Age  int    `json:"age"`
//	}
//	user := User{Name: "John", Age: 30}
//	jsonStr, err := Struct2JSON(user, true)
func Struct2JSON(t interface{}, pretty bool) (string, error) {
	// 如果输入已经是字符串，直接返回
	if s, ok := t.(string); ok {
		return s, nil
	}

	// 创建缓冲区并初始化JSON编码器
	bf := bytes.NewBuffer([]byte{})
	jsonEncoder := json.NewEncoder(bf)
	jsonEncoder.SetEscapeHTML(false) // 禁用HTML转义

	// 编码结构体
	if err := jsonEncoder.Encode(t); err != nil {
		return "", err
	}

	// 根据pretty参数决定是否格式化输出
	if !pretty {
		return strings.TrimSpace(bf.String()), nil
	}
	return formatJSON(bf.Bytes())
}

// formatJSON 格式化JSON数据
//
// 参数：
//
//	content - 要格式化的JSON字节数组
//
// 返回值：
//
//	string - 格式化后的JSON字符串
//	error - 格式化过程中可能发生的错误
//
// 注意：
//
//	该函数主要用于内部使用，通常不直接调用
func formatJSON(content []byte) (string, error) {
	var p bytes.Buffer
	if err := json.Indent(&p, content, "", "  "); err != nil {
		return "", err
	}
	return strings.TrimSpace(p.String()), nil
}

// JsonPretty 格式化JSON字符串
//
// 参数：
//
//	content - 要格式化的JSON字符串
//
// 返回值：
//
//	格式化后的JSON字符串
//
// 示例：
//
//	pretty := JsonPretty(`{"name":"John"}`) // 返回格式化后的JSON
func JsonPretty(content string) string {
	var p bytes.Buffer
	json.Indent(&p, []byte(content), "", "  ")
	return p.String()
}

// JsonPretty4Byte 格式化JSON字节数组
//
// 参数：
//
//	content - 要格式化的JSON字节数组
//
// 返回值：
//
//	格式化后的JSON字符串
//
// 示例：
//
//	pretty := JsonPretty4Byte([]byte(`{"name":"John"}`)) // 返回格式化后的JSON
func JsonPretty4Byte(content []byte) string {
	var p bytes.Buffer
	json.Indent(&p, content, "", "  ")
	return p.String()
}

// Struct2JsonNoError 将结构体转换为JSON字符串，忽略错误
//
// 参数：
//
//	t - 要转换的结构体或值
//	pretty - 是否格式化输出
//
// 返回值：
//
//	string - 转换后的JSON字符串
//
// 注意：
//
//	该函数会忽略转换过程中发生的错误，适用于确定不会出错的情况
//
// 示例：
//
//	type User struct {
//	    Name string `json:"name"`
//	}
//	user := User{Name: "Alice"}
//	jsonStr := Struct2JsonNoError(user, false)
func Struct2JsonNoError(t interface{}, pretty bool) string {
	result, _ := Struct2JSON(t, pretty)
	return result
}

// Json2Interface 将JSON字节反序列化为接口
//
// 参数：
//
//	b - 要反序列化的JSON字节数组
//	i - 目标接口指针
//
// 返回值：
//
//	error - 反序列化过程中可能发生的错误
//
// 示例：
//
//	var user User
//	err := Json2Interface([]byte(`{"name":"Bob"}`), &user)
func Json2Interface(b []byte, i interface{}) error {
	d := json.NewDecoder(bytes.NewReader(b))
	d.UseNumber() // 使用Number类型处理数字
	return d.Decode(i)
}

// I2S 将接口转换为JSON字符串
//
// 参数：
//
//	i - 要转换的接口
//
// 返回值：
//
//	string - 转换后的JSON字符串
//
// 注意：
//
//	该函数是Struct2JsonNoError的快捷方式，默认不格式化输出
//
// 示例：
//
//	data := map[string]interface{}{"key": "value"}
//	jsonStr := I2S(data)
func I2S(i interface{}) string {
	return Struct2JsonNoError(i, false)
}

// B2I 将JSON字节转换为接口
//
// 参数：
//
//	b - 要转换的JSON字节数组
//	i - 目标接口指针
//
// 返回值：
//
//	error - 转换过程中可能发生的错误
//
// 注意：
//
//	该函数是Json2Interface的别名，提供更直观的函数命名
//
// 示例：
//
//	var result map[string]interface{}
//	err := B2I([]byte(`{"key":"value"}`), &result)
func B2I(b []byte, i interface{}) error {
	return Json2Interface(b, i)
}

// S2I 将JSON字符串转换为接口
//
// 参数：
//
//	s - 要转换的JSON字符串
//	i - 目标接口指针
//
// 返回值：
//
//	error - 转换过程中可能发生的错误
//
// 注意：
//
//	该函数是Json2Interface的快捷方式，自动处理字符串到字节数组的转换
//
// 示例：
//
//	var config Config
//	err := S2I(`{"setting":"value"}`, &config)
func S2I(s string, i interface{}) error {
	return Json2Interface([]byte(s), i)
}
